﻿using AudiPyme.DAL;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Data.EntityClient;
using System.Data.Objects;

namespace AudiPyme.Testing
{


    /// <summary>
    ///Se trata de una clase de prueba para ModeloContainerTest y se pretende que
    ///contenga todas las pruebas unitarias ModeloContainerTest.
    ///</summary>
    [TestClass()]
    public class ModeloContainerTest
    {


        private TestContext testContextInstance;

        /// <summary>
        ///Obtiene o establece el contexto de la prueba que proporciona
        ///la información y funcionalidad para la ejecución de pruebas actual.
        ///</summary>
        public TestContext TestContext
        {
            get
            {
                return testContextInstance;
            }
            set
            {
                testContextInstance = value;
            }
        }

        #region Atributos de prueba adicionales
        // 
        //Puede utilizar los siguientes atributos adicionales mientras escribe sus pruebas:
        //
        //Use ClassInitialize para ejecutar código antes de ejecutar la primera prueba en la clase 
        //[ClassInitialize()]
        //public static void MyClassInitialize(TestContext testContext)
        //{
        //}
        //
        //Use ClassCleanup para ejecutar código después de haber ejecutado todas las pruebas en una clase
        //[ClassCleanup()]
        //public static void MyClassCleanup()
        //{
        //}
        //
        //Use TestInitialize para ejecutar código antes de ejecutar cada prueba
        //[TestInitialize()]
        //public void MyTestInitialize()
        //{
        //}
        //
        //Use TestCleanup para ejecutar código después de que se hayan ejecutado todas las pruebas
        //[TestCleanup()]
        //public void MyTestCleanup()
        //{
        //}
        //
        #endregion


        /// <summary>
        ///Una prueba de Constructor ModeloContainer
        ///</summary>
        [TestMethod()]
        public void ModeloContainerConstructorTest()
        {
            ModeloContainer target = new ModeloContainer();
            Assert.IsNotNull(target);

        }

        /// <summary>
        ///Una prueba de Constructor ModeloContainer
        ///</summary>
        [TestMethod()]
        public void ModeloContainerConstructorTest1()
        {
            string connectionString = null; // TODO: Inicializar en un valor adecuado
            try
            {
                ModeloContainer target = new ModeloContainer(connectionString);
                Assert.Fail();
            }
            catch (System.ArgumentNullException ex)
            {
                Assert.IsNotNull(ex);
            }

        }
        /*
        /// <summary>
        ///Una prueba de Constructor ModeloContainer
        ///</summary>
        [TestMethod()]
        public void ModeloContainerConstructorTest2()
        {
            ModeloContainer target = new ModeloContainer();
            Assert.Inconclusive("TODO: Implementar código para comprobar el destino");
        }
        /// <summary>
        ///Una prueba de AddToActivosEmpresaEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToActivosEmpresaEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ActivosEmpresa activosEmpresa = null; // TODO: Inicializar en un valor adecuado
            target.AddToActivosEmpresaEstablecer(activosEmpresa);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToAmenazasEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToAmenazasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Amenazas amenazas = null; // TODO: Inicializar en un valor adecuado
            target.AddToAmenazasEstablecer(amenazas);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Controles controles = null; // TODO: Inicializar en un valor adecuado
            target.AddToControlesEstablecer(controles);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToControles_ActivosEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToControles_ActivosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Controles_Activos controles_Activos = null; // TODO: Inicializar en un valor adecuado
            target.AddToControles_ActivosEstablecer(controles_Activos);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToCriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToCriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            CriteriosRiesgo criteriosRiesgo = null; // TODO: Inicializar en un valor adecuado
            target.AddToCriteriosRiesgoEstablecer(criteriosRiesgo);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToDominiosEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToDominiosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Dominios dominios = null; // TODO: Inicializar en un valor adecuado
            target.AddToDominiosEstablecer(dominios);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToEmpresasEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToEmpresasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Empresas empresas = null; // TODO: Inicializar en un valor adecuado
            target.AddToEmpresasEstablecer(empresas);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToInstanciaAmenazasControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToInstanciaAmenazasControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            InstanciaAmenazasControles instanciaAmenazasControles = null; // TODO: Inicializar en un valor adecuado
            target.AddToInstanciaAmenazasControlesEstablecer(instanciaAmenazasControles);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToInstanciaAmenazasVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToInstanciaAmenazasVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            InstanciaAmenazasVulnerabilidades instanciaAmenazasVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToInstanciaAmenazasVulnerabilidadesEstablecer(instanciaAmenazasVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToInstanciaTiposActivosAmenazasCriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToInstanciaTiposActivosAmenazasCriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            InstanciaTiposActivosAmenazasCriteriosRiesgo instanciaTiposActivosAmenazasCriteriosRiesgo = null; // TODO: Inicializar en un valor adecuado
            target.AddToInstanciaTiposActivosAmenazasCriteriosRiesgoEstablecer(instanciaTiposActivosAmenazasCriteriosRiesgo);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToInstanciaTiposActivosVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToInstanciaTiposActivosVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            InstanciaTiposActivosVulnerabilidades instanciaTiposActivosVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToInstanciaTiposActivosVulnerabilidadesEstablecer(instanciaTiposActivosVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToMatriz_AmenazasVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToMatriz_AmenazasVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Matriz_AmenazasVulnerabilidades matriz_AmenazasVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToMatriz_AmenazasVulnerabilidadesEstablecer(matriz_AmenazasVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToMatriz_Amenazas_ControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToMatriz_Amenazas_ControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Matriz_Amenazas_Controles matriz_Amenazas_Controles = null; // TODO: Inicializar en un valor adecuado
            target.AddToMatriz_Amenazas_ControlesEstablecer(matriz_Amenazas_Controles);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToMatriz_TipoActivosAmenazasCriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToMatriz_TipoActivosAmenazasCriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Matriz_TipoActivosAmenazasCriteriosRiesgo matriz_TipoActivosAmenazasCriteriosRiesgo = null; // TODO: Inicializar en un valor adecuado
            target.AddToMatriz_TipoActivosAmenazasCriteriosRiesgoEstablecer(matriz_TipoActivosAmenazasCriteriosRiesgo);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToMatriz_TiposActivosVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToMatriz_TiposActivosVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Matriz_TiposActivosVulnerabilidades matriz_TiposActivosVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToMatriz_TiposActivosVulnerabilidadesEstablecer(matriz_TiposActivosVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToNomMatrizAmenazasVulnerabilidades
        ///</summary>
        [TestMethod()]
        public void AddToNomMatrizAmenazasVulnerabilidadesTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            NomMatrizAmenazasVulnerabilidades nomMatrizAmenazasVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToNomMatrizAmenazasVulnerabilidades(nomMatrizAmenazasVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToNomMatrizTiposActivosAmenazasCriteriosRiesgo
        ///</summary>
        [TestMethod()]
        public void AddToNomMatrizTiposActivosAmenazasCriteriosRiesgoTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            NomMatrizTiposActivosAmenazasCriteriosRiesgo nomMatrizTiposActivosAmenazasCriteriosRiesgo = null; // TODO: Inicializar en un valor adecuado
            target.AddToNomMatrizTiposActivosAmenazasCriteriosRiesgo(nomMatrizTiposActivosAmenazasCriteriosRiesgo);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToNomMatrizTiposActivosVulnerabilidades
        ///</summary>
        [TestMethod()]
        public void AddToNomMatrizTiposActivosVulnerabilidadesTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            NomMatrizTiposActivosVulnerabilidades nomMatrizTiposActivosVulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToNomMatrizTiposActivosVulnerabilidades(nomMatrizTiposActivosVulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToObjetivosControlEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToObjetivosControlEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjetivosControl objetivosControl = null; // TODO: Inicializar en un valor adecuado
            target.AddToObjetivosControlEstablecer(objetivosControl);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToPesosSectoresEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToPesosSectoresEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            PesosSectores pesosSectores = null; // TODO: Inicializar en un valor adecuado
            target.AddToPesosSectoresEstablecer(pesosSectores);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToReglasMadurezEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToReglasMadurezEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ReglasMadurez reglasMadurez = null; // TODO: Inicializar en un valor adecuado
            target.AddToReglasMadurezEstablecer(reglasMadurez);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToSectoresEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToSectoresEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Sectores sectores = null; // TODO: Inicializar en un valor adecuado
            target.AddToSectoresEstablecer(sectores);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToTipoEmpresasEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToTipoEmpresasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            TipoEmpresas tipoEmpresas = null; // TODO: Inicializar en un valor adecuado
            target.AddToTipoEmpresasEstablecer(tipoEmpresas);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToTiposActivosEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToTiposActivosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            TiposActivos tiposActivos = null; // TODO: Inicializar en un valor adecuado
            target.AddToTiposActivosEstablecer(tiposActivos);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToTiposAmenazasEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToTiposAmenazasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            TiposAmenazas tiposAmenazas = null; // TODO: Inicializar en un valor adecuado
            target.AddToTiposAmenazasEstablecer(tiposAmenazas);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToUsuariosEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToUsuariosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Usuarios usuarios = null; // TODO: Inicializar en un valor adecuado
            target.AddToUsuariosEstablecer(usuarios);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToValoresReglasEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToValoresReglasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ValoresReglas valoresReglas = null; // TODO: Inicializar en un valor adecuado
            target.AddToValoresReglasEstablecer(valoresReglas);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddToVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void AddToVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            Vulnerabilidades vulnerabilidades = null; // TODO: Inicializar en un valor adecuado
            target.AddToVulnerabilidadesEstablecer(vulnerabilidades);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de AddTosysdiagrams
        ///</summary>
        [TestMethod()]
        public void AddTosysdiagramsTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            sysdiagrams sysdiagrams = null; // TODO: Inicializar en un valor adecuado
            target.AddTosysdiagrams(sysdiagrams);
            Assert.Inconclusive("Un método que no devuelve ningún valor no se puede comprobar.");
        }

        /// <summary>
        ///Una prueba de ActivosEmpresaEstablecer
        ///</summary>
        [TestMethod()]
        public void ActivosEmpresaEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<ActivosEmpresa> actual;
            actual = target.ActivosEmpresaEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de AmenazasEstablecer
        ///</summary>
        [TestMethod()]
        public void AmenazasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Amenazas> actual;
            actual = target.AmenazasEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de ControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void ControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Controles> actual;
            actual = target.ControlesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de Controles_ActivosEstablecer
        ///</summary>
        [TestMethod()]
        public void Controles_ActivosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Controles_Activos> actual;
            actual = target.Controles_ActivosEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de CriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void CriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<CriteriosRiesgo> actual;
            actual = target.CriteriosRiesgoEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de DominiosEstablecer
        ///</summary>
        [TestMethod()]
        public void DominiosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Dominios> actual;
            actual = target.DominiosEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de EmpresasEstablecer
        ///</summary>
        [TestMethod()]
        public void EmpresasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Empresas> actual;
            actual = target.EmpresasEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de InstanciaAmenazasControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void InstanciaAmenazasControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<InstanciaAmenazasControles> actual;
            actual = target.InstanciaAmenazasControlesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de InstanciaAmenazasVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void InstanciaAmenazasVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<InstanciaAmenazasVulnerabilidades> actual;
            actual = target.InstanciaAmenazasVulnerabilidadesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de InstanciaTiposActivosAmenazasCriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void InstanciaTiposActivosAmenazasCriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<InstanciaTiposActivosAmenazasCriteriosRiesgo> actual;
            actual = target.InstanciaTiposActivosAmenazasCriteriosRiesgoEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de InstanciaTiposActivosVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void InstanciaTiposActivosVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<InstanciaTiposActivosVulnerabilidades> actual;
            actual = target.InstanciaTiposActivosVulnerabilidadesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de Matriz_AmenazasVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void Matriz_AmenazasVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Matriz_AmenazasVulnerabilidades> actual;
            actual = target.Matriz_AmenazasVulnerabilidadesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de Matriz_Amenazas_ControlesEstablecer
        ///</summary>
        [TestMethod()]
        public void Matriz_Amenazas_ControlesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Matriz_Amenazas_Controles> actual;
            actual = target.Matriz_Amenazas_ControlesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de Matriz_TipoActivosAmenazasCriteriosRiesgoEstablecer
        ///</summary>
        [TestMethod()]
        public void Matriz_TipoActivosAmenazasCriteriosRiesgoEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Matriz_TipoActivosAmenazasCriteriosRiesgo> actual;
            actual = target.Matriz_TipoActivosAmenazasCriteriosRiesgoEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de Matriz_TiposActivosVulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void Matriz_TiposActivosVulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Matriz_TiposActivosVulnerabilidades> actual;
            actual = target.Matriz_TiposActivosVulnerabilidadesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de NomMatrizAmenazasVulnerabilidades
        ///</summary>
        [TestMethod()]
        public void NomMatrizAmenazasVulnerabilidadesTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<NomMatrizAmenazasVulnerabilidades> actual;
            actual = target.NomMatrizAmenazasVulnerabilidades;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de NomMatrizTiposActivosAmenazasCriteriosRiesgo
        ///</summary>
        [TestMethod()]
        public void NomMatrizTiposActivosAmenazasCriteriosRiesgoTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<NomMatrizTiposActivosAmenazasCriteriosRiesgo> actual;
            actual = target.NomMatrizTiposActivosAmenazasCriteriosRiesgo;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de NomMatrizTiposActivosVulnerabilidades
        ///</summary>
        [TestMethod()]
        public void NomMatrizTiposActivosVulnerabilidadesTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<NomMatrizTiposActivosVulnerabilidades> actual;
            actual = target.NomMatrizTiposActivosVulnerabilidades;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de ObjetivosControlEstablecer
        ///</summary>
        [TestMethod()]
        public void ObjetivosControlEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<ObjetivosControl> actual;
            actual = target.ObjetivosControlEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de PesosSectoresEstablecer
        ///</summary>
        [TestMethod()]
        public void PesosSectoresEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<PesosSectores> actual;
            actual = target.PesosSectoresEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de ReglasMadurezEstablecer
        ///</summary>
        [TestMethod()]
        public void ReglasMadurezEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<ReglasMadurez> actual;
            actual = target.ReglasMadurezEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de SectoresEstablecer
        ///</summary>
        [TestMethod()]
        public void SectoresEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Sectores> actual;
            actual = target.SectoresEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de TipoEmpresasEstablecer
        ///</summary>
        [TestMethod()]
        public void TipoEmpresasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<TipoEmpresas> actual;
            actual = target.TipoEmpresasEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de TiposActivosEstablecer
        ///</summary>
        [TestMethod()]
        public void TiposActivosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<TiposActivos> actual;
            actual = target.TiposActivosEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de TiposAmenazasEstablecer
        ///</summary>
        [TestMethod()]
        public void TiposAmenazasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<TiposAmenazas> actual;
            actual = target.TiposAmenazasEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de UsuariosEstablecer
        ///</summary>
        [TestMethod()]
        public void UsuariosEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Usuarios> actual;
            actual = target.UsuariosEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de ValoresReglasEstablecer
        ///</summary>
        [TestMethod()]
        public void ValoresReglasEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<ValoresReglas> actual;
            actual = target.ValoresReglasEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de VulnerabilidadesEstablecer
        ///</summary>
        [TestMethod()]
        public void VulnerabilidadesEstablecerTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<Vulnerabilidades> actual;
            actual = target.VulnerabilidadesEstablecer;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }

        /// <summary>
        ///Una prueba de sysdiagrams
        ///</summary>
        [TestMethod()]
        public void sysdiagramsTest()
        {
            ModeloContainer target = new ModeloContainer(); // TODO: Inicializar en un valor adecuado
            ObjectSet<sysdiagrams> actual;
            actual = target.sysdiagrams;
            Assert.Inconclusive("Compruebe la exactitud de este método de prueba.");
        }
    
         * */
    }
}
